Computing the Envelope for Stepwise-Constant Resource Allocations

Computing tight resource-level bounds is a fundamental problem in the construction of flexible plans with resource utilization. In this paper we describe an efficient algorithm that builds a resource envelope, the tightest possible such bound. The algorithm is based on transforming the temporal network of resource consuming and producing events into a flow network with nodes equal to the events and edges equal to the necessary predecessor links between events. A staged maximum flow problem on the network is then used to compute the time of occurrence and the height of each step of the resource envelope profile. Each stage has the same computational complexity of solving a maximum flow problem on the entire flow network. This makes this method computationally feasible and promising for use in the inner loop of flexible-time scheduling algorithms. 1 Resource Envelopes Retaining temporal flexibility in activity plans is important for dealing with execution uncertainty. For example, flexible plans allow explicit reasoning about the temporal uncontrollability of exogenous events [11] and the seamless incorporation of execution countermeasures. Fixed-time schedules (i.e., the assignment of a precise start and end time to all activities) are brittle and it is typically very difficult to exactly follow them during execution. For an example of the effect of fixed-time schedules in an intelligent execution situation, consider the “Skylab strike” [6], when during the Skylab 4 mission, astronauts went on a sit-down strike after 45 days of trying to catch up with the exact demands of a fast paced schedule with no flexibility for them to adjust to the space environment. A major obstacle to using flexible schedules, however, remains the difficulty of computing the amount of resources needed across all of their possible executions. This problem is particularly difficult for multiple-capacity resources (such as electrical power) that can be both consumed and produced in any amount by concurrent activities. Techniques have been developed [5] [10] for giving conservative estimates of the resource levels needed by a flexible schedule, yielding both an upper bound and a lower bound profile on the resource level over time. In the context of a systematic search method to build flexible plans, resource-level bounds can be used at each search step as follows: a) as a backtracking test, i.e., to determine when the lower/upper bound interval is outside of the range of allowed resource levels at some time and therefore no fixed-time instantiations of the plan is resource-feasible; and b) as a search termination test, i.e., to determine when the lower/upper bound range is inside the range of allowed resource levels at all times and therefore all fixed-time instantiations of the plan are resource-feasible. Bound tightness is extremely important computationally since a tight bound can save a potentially exponential amount of search (through early backtracking and solution detection) when compared to a looser bound. In this paper, we discuss how to compute the resourcelevel envelope, i.e., the measure of maximum and minimum resource consumption at any time for all fixed-time schedules in the flexible plan. At each time the envelope guarantees that there are two fixed-time instantiations, one producing the minimum level and the other the maximum. Therefore, the resource-level envelope is the tightest possible resource-level bound for a flexible plan since any tighter bound would exclude the contribution of at least one fixed-time schedule. If the resource-level envelope can be computed efficiently, it could substitute looser bounds that are currently used in the inner core of constraint-posting scheduling algorithms (Laborie 2001) with the potential for great improvements in performance. To appreciate the difficulty of computing the resource level, we can compare the cases of a fully flexible plan with that of a plan with a single fixed-time instantiation. In the fixed-time case, the envelope degenerates to the resource profile that is used in the inner loop of traditional scheduling algorithms [2][15]. Computing from scratch a resource profile is cheap. It is easy to see that its worst cast time complexity is O (N lg N) where N is the number of activities in the flexible plan. Consider now a fully flexible plan and assume that we naively wanted to compute the resource-level envelope for a flexible plan by simply enumerating all schedules and taking the maximum/minimum of all resource levels at all times. Since a flexible activity plan has a number of possible instantiated fixed-time schedules that is exponential in the number of events, such naïve method is clearly impractical in most cases. Note that “resource-level envelope calculation” is not equivalent to “scheduling with multiple capacity”, an NP-hard problem. For example, note that a reduction of the envelope calculation to scheduling is not straightforward. Consider the interval between minimum and maximum envelope at a given time. It is true that a solution to the scheduling problem can be obtained in polynomial time if the envelope interval is always completely contained within resource availability (in which case all fixed-time instantiations are legal schedules). However, if at least two times the envelope interval is partly outside the availability bound, one can generate examples in which the envelope cannot tell us whether there is a fixed-time schedule that is within availability at all times or whether for all schedules the resource level is outside availability at some time. Discriminating between these two cases still requires search. This paper presents a polynomial algorithm for the computation of resource-level envelopes based on a novel combination of the theory of shortest-paths in the temporal constraint network for the flexible plan, and the theory of maximum flows for a flow network derived from the temporal and resource constraints. We develop the theory, show that the algorithm is correct, and that its asymptotic complexity is O(N O(maxflow(N))), where N is the number of start/end times of the activities in the plan, which is at most twice the number of activities, and O(maxflow(N)) is the complexity of a maximum flow algorithm applied to an auxiliary flow network with N nodes. We believe that this method will be efficient in practice, since experimental analysis [1] show the practical cost of maxflow to be as good as O (N ). However this paper is a theoretical contribution and a definitive answer to its practical complexity will require further experimental work. In the rest of the paper we introduce some notation and describe the formal model of activity networks with resource consumption. Then we review the literature on resource contention measures and show an example in which the current state of the art is inadequate. The discussion of our algorithm follows. Some informal examples to establish an intuitive understanding of our method are first given. Then we establish the connection between maximum flow problems and finding sets of activities that have the optimal contribution to the resource level. These sets are then shown to compute an envelope. Finally, we describe a simple envelope algorithm and its complexity, and conclude discussing future work. 2 Resource Envelopes Figure 1 shows an activity network with resource allocations. Our notation is equivalent to that of previous work on flexible scheduling with multiple-capacity resources [5][10]. The network has two time variables per activity, a start event and an end event (e.g., e1s and e1e for activity A1), a non-negative flexible activity duration link (e.g., [2, 5] for activity A1), and flexible separation links between events (e.g., [0, 4] from e3e to e4s). A time origin, Ts, corresponds to time 0 and supports separation links to other events. Without loss of generality we assume that all events occur after Ts and before an event Te rigidly connected to Ts. The interval TsTe is the time horizon T of the network. Figure 1: An activity network with resource allocations Time origin, events and links constitute a Simple Temporal Network (STN) [8]. Unlike regular STNs, however, each event has an associated allocation variable with real domain (e.g., r31 for event e3s) representing the amount of resource allocated when the event occurs. We call this augmented network R a piecewise-constant Resource allocation STN (cR-STN). In the following we will assume that all allocations refer to a single, multi-capacity resource. The extension of the results to the case of multiple resources is straightforward. An event e with negative allocation is a consumer, while an e with positive allocation is a producer. This formalization covers many of the usual models for resource allocations. For example, note that an event can be either a consumer or a producer in different instantiations of the allocation variables (e.g., event e2s for which the bound for r21 is [-1, 3]). This allows reasoning about dual-use activities (e.g., the activities of starting a car and running it make use of the alternator as either a power consumer or producer). Moreover, some events can have resource allocations that are opposite to each other (e.g., e1e vs. e1s). This allows modeling allocations that last only during an activity’s occurrence, such as power consumption. Note, however, that this model does not cover continuous accumulation such as change of energy stored in a battery over time. A conservative approximation can be achieved by accounting for the entire resource usage at the activity start or end. We will always assume that the cR-STN is temporally consistent. From the STN theory [8], this means that the shortest-path problem associated with R has a solution. Given two events e1 and e2 we denote with |e1e2| the shortest-path from e1 to e2. We will call a full instantiation of the time variables in R a schedule s(.) where s(e) is the time of occurrence of event e according to schedule s. The set S contains all possible consistent schedules for R. Each event e has a time bound [et(e), lt(e)], with et(e) and lt(e) respectively the earliest and latest time for e. The time bound represents the range of possible time values s(e) for all s∈ S. From the STN theory, we know that et(e) = − |eTs| and lt(e) = |Tse|. Finally, given three events, e1, e2 and e3, the triangular inequality among shortest paths |e1e3| ≤ |e1e2| + |e2e3| holds. A fundamental data structure used in the rest of the paper is the anti-precedence graph, Aprec(R), for a cR-STN R. The anti-precedence graph is similar to the precedence graph of [10] with the following differences: a) the links are in reverse order; 2) it does not distinguish between the set of strict precedence edges, E<, and the set of precedence edges that allow time [1, 10]